home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / perl5 / Gtk2 / SimpleMenu.pm < prev    next >
Text File  |  2009-05-17  |  8KB  |  342 lines
  1. #
  2. # $Id$
  3. #
  4.  
  5. package Gtk2::SimpleMenu;
  6.  
  7. use strict;
  8. use warnings;
  9. use Carp;
  10. use Gtk2;
  11.  
  12. our @ISA = 'Gtk2::ItemFactory';
  13.  
  14. our $VERSION = 0.50;
  15.  
  16. sub new
  17. {
  18.     my $class = shift;
  19.     my %opts = ( @_ );
  20.     
  21.     # create an accel group to pass to the item factory call, it's later
  22.     # stored so that our owner can add the accel group to something
  23.     my $accel_group = Gtk2::AccelGroup->new;
  24.     
  25.     # create the item factory providing a accel_group.
  26.     my $self = Gtk2::ItemFactory->new('Gtk2::MenuBar', '<main>', $accel_group);
  27.  
  28.     # put the options into the simple item object
  29.     foreach (keys %opts)
  30.     {
  31.         $self->{$_} = $opts{$_};
  32.     }
  33.     
  34.     bless($self, $class);
  35.     
  36.     # convert our menu_tree into a set of entries for itemfactory
  37.     $self->parse;
  38.     # create the entries 
  39.     foreach (@{$self->{entries}})
  40.     {
  41.         $self->create_item ($_, $_->[6] || $self->{user_data});
  42.     }
  43.     # store the widget so our owner can easily get to it
  44.     $self->{widget} = $self->get_widget('<main>');
  45.     # cache the accel_group so the user can add it to something,
  46.     # the window, if they so choose
  47.     $self->{accel_group} = $accel_group;
  48.  
  49.     delete $self->{entries} unless( $self->{keep_entries} );
  50.     delete $self->{menu_tree} unless( $self->{keep_menu_tree} );
  51.  
  52.     return $self;
  53. }
  54.  
  55.  
  56. sub parse
  57. {
  58.     my $self = shift;
  59.  
  60.     our @entries = ();
  61.     our @groups = ();
  62.     our $default_callback = $self->{default_callback};
  63.  
  64.     # called below (for 'root' branch) and the recusively for each branch
  65.     sub parse_level
  66.     {
  67.         my $path = shift;
  68.         my $label = shift;
  69.         my $itms = shift;
  70.     
  71.         # we need a type to test to prevent warnings,
  72.         # just use one that will fall through to defaul
  73.         $itms->{item_type} = ''
  74.             unless( exists($itms->{item_type}) );
  75.  
  76.         if( $itms->{item_type} eq 'root' )
  77.         {
  78.             # special type for first call, doesn't add entry
  79.             my $i = 0;
  80.             for($i = 0; $i < scalar(@{$itms->{children}}); $i += 2)
  81.             {
  82.                 parse_level ('/',
  83.                     $itms->{children}[$i],
  84.                     $itms->{children}[$i+1]);
  85.             }
  86.         }
  87.         elsif( $itms->{item_type} =~ /Branch/ )
  88.         {
  89.             # add the branch item
  90.             push @entries, [ $path.$label,
  91.                      undef,
  92.                      undef,
  93.                      undef,
  94.                      $itms->{item_type}, ];
  95.             # remove mnemonics from path
  96.             $label =~ s/_//g;
  97.             # then for each of its children parse that level
  98.             my $i = 0;
  99.             for( $i = 0; $i < scalar(@{$itms->{children}}); $i += 2)
  100.             {
  101.                 parse_level ($path.$label.'/',
  102.                     $itms->{children}[$i],
  103.                     $itms->{children}[$i+1]);
  104.             }
  105.         }
  106.         elsif( $itms->{item_type} =~ /Radio/ )
  107.         {
  108.             # cache the groupid
  109.             my $grp = $itms->{groupid};
  110.  
  111.             # add this radio item to the existing group, if one,
  112.             # otherwise use item_type
  113.             push @entries, [ $path.$label,
  114.                      $itms->{accelerator},
  115.                      (exists($itms->{callback}) ? 
  116.                          $itms->{callback} : 
  117.                          $default_callback ),
  118.                      $itms->{callback_action},
  119.                      (exists($groups[$grp]) ? 
  120.                          $groups[$grp] :
  121.                          $itms->{item_type}), 
  122.                      $itms->{extra_data},
  123.                      $itms->{callback_data} ];
  124.  
  125.             # create the group identifier (path)
  126.             # so that next button in this group will
  127.             # be added to existing group
  128.             unless( exists($groups[$grp]) )
  129.             {
  130.                 $groups[$grp] = $path.$label;
  131.                 $groups[$grp] =~ s/_//g;
  132.             }
  133.         }
  134.         else
  135.         {
  136.             # everything else just gets created with its values
  137.             push @entries, [ $path.$label,
  138.                      $itms->{accelerator},
  139.                      (exists($itms->{callback}) ? 
  140.                          $itms->{callback} : 
  141.                          $default_callback ),
  142.                      $itms->{callback_action},
  143.                      $itms->{item_type},
  144.                      $itms->{extra_data}, 
  145.                      $itms->{callback_data} ];
  146.         }
  147.     }
  148.  
  149.     # fake up a root branch with the menu_tree as it's children
  150.     parse_level (undef, undef, { 
  151.             item_type => 'root', 
  152.             children => $self->{menu_tree} });
  153.  
  154.     # store the itemfactory entries array
  155.     $self->{entries} = \@entries;
  156. }
  157.  
  158. 1;
  159. __END__
  160. # documentation is a good thing.
  161.  
  162. =head1 NAME
  163.  
  164. Gtk2::SimpleMenu - A simple interface to Gtk2's ItemFactory for creating
  165. application menus
  166.  
  167. =head1 SYNOPSIS
  168.  
  169.   use Gtk2 '-init';
  170.   use Gtk2::SimpleMenu;
  171.  
  172.   my $menu_tree = [
  173.       _File => {
  174.         item_type => '<Branch>',
  175.         children => [
  176.             _New => {
  177.                 callback => \&new_cb,
  178.                 callback_action => 0,
  179.                 accelerator => '<ctrl>N',
  180.             },
  181.             _Save => {
  182.                 callback_action => 1,
  183.                 callback_data => 'per entry cbdata',
  184.                 accelerator => '<ctrl>S',
  185.             },
  186.             _Exec => {
  187.                 item_type => '<StockItem>',
  188.                 callback_action => 2,
  189.                 extra_data => 'gtk-execute',
  190.             },
  191.             _Quit => {
  192.                 callback => sub { Gtk2->main_quit; },
  193.                 callback_action => 3,
  194.                 accelerator => '<ctrl>Q',
  195.             },
  196.         ],
  197.     },
  198.     _Mode => {
  199.         _First => {
  200.             item_type => '<RadioItem>',
  201.             callback => \&mode_callback,
  202.             callback_action => 4,
  203.             groupid => 1,
  204.         },
  205.         _Second => {
  206.             item_type => '<RadioItem>',
  207.             callback => \&mode_callback,
  208.             callback_action => 5,
  209.             groupid => 1,
  210.         },
  211.         _Third => {
  212.             item_type => '<RadioItem>',
  213.             callback => \&mode_callback,
  214.             callback_action => 6,
  215.             groupid => 1,
  216.         },
  217.     }
  218.     _Help => {
  219.         children => [
  220.             _Tearoff => {
  221.                 item_type => '<Tearoff>',
  222.             },
  223.             _CheckItem => {
  224.                 item_type => '<CheckItem>',
  225.                 callback_action => 7,
  226.             },
  227.             Separator => {
  228.                 item_type => '<Separator>',
  229.             },
  230.             _Contents => {
  231.                 callback_action => 8, 
  232.             },
  233.             _About => {
  234.                 callback_action => 9, 
  235.             },
  236.         ]
  237.     }
  238.   ];
  239.  
  240.   my $menu = Gtk2::SimpleMenu->new (
  241.           menu_tree => $menu_tree,
  242.         default_callback => \&default_callback,
  243.         user_data => 'user_data',
  244.     );
  245.  
  246.   # an example of how to get to the menuitems.
  247.   $menu->get_widget('/File/Save')->activate;
  248.     
  249.   $container->add ($menu->{widget});
  250.  
  251. =head1 ABSTRACT
  252.  
  253. SimpleMenu is an interface for creating application menubars in as simple a
  254. manner as possible. Its main benifit is that the menu is specified as a tree,
  255. which is the natural representation of such a menu.
  256.  
  257. =head1 DESCRIPTION
  258.  
  259. SimpleMenu aims to simplify the design and management of a complex application
  260. menu bar by allowing the structure to be specified as a multi-rooted tree. Much
  261. the same functionality is provided by Gtk2::ItemFactory, but the data provided
  262. as input is a 1-D array and the hierarchy of the menu is controled entierly by
  263. the path componenets. This is not ideal when languages such as perl provide for
  264. simple nested data structures.
  265.  
  266. Another advantage of the SimpleMenu widget is that it simplifies the creation
  267. and use of accelerators.
  268.  
  269. SimpleMenu is a child of Gtk2::ItemFactory, so that it may be treated as such.
  270. Any method that can be called on a ItemFactory can be called on a SimpleMenu.
  271.  
  272. =head1 OBJECT HIERARCHY
  273.  
  274.  Glib::Object
  275.  +--- Gtk2::Object
  276.       +--- Gtk2::ItemFactory
  277.            +--- Gtk2::SimpleMenu
  278.  
  279. =head1 FUNCTIONS
  280.  
  281. =over
  282.  
  283. =item $menu = Gtk2::SimpleMenu->new (menu_tree => $menu_tree, ...)
  284.  
  285. Creates a new Gtk2::SimpleMenu object with the specified tree. Optionally key
  286. value paris providing a default_callback and user_data can be provided as well.
  287. After creating the menu object all of the subsequent widgets will have been
  288. created and are ready for use.
  289.  
  290. =back
  291.  
  292. =head1 MEMBER VARIABLES
  293.  
  294. =over
  295.  
  296. =item $menu->{widget}
  297.  
  298. The Gtk2::MenuBar root of the SimpleMenu. This is what should be added to the
  299. widget which will contain the SimpleMenu.
  300.  
  301.   $container->add ($menu->{widget});
  302.  
  303. =item $menu->{accel_group}
  304.  
  305. The Gtk2::AccellGroup created by the menu tree. Normally accell_group would be
  306. added to the main window of an application, but this is only necessary if
  307. accelerators are being used in the menu tree's items. 
  308.  
  309.   $win->add_accel_group ($menu->{accel_group});
  310.  
  311. =back
  312.  
  313. =head1 SEE ALSO
  314.  
  315. Perl(1), Glib(3pm), Gtk2(3pm), examples/simple_menu.pl.
  316.  
  317. Note: Gtk2::SimpleMenu is deprecated in favor of Gtk2::Ex::Simple::Menu, part of the Gtk2-Perl-Ex project at L<http://gtk2-perl-ex.sf.net/> .
  318.  
  319. =head1 AUTHORS
  320.  
  321.  Ross McFarland <rwmcfa1 at neces dot com>
  322.  
  323. =head1 COPYRIGHT AND LICENSE
  324.  
  325. Copyright 2003 by the Gtk2-Perl team.
  326.  
  327. This library is free software; you can redistribute it and/or modify it under
  328. the terms of the GNU Library General Public License as published by the Free
  329. Software Foundation; either version 2.1 of the License, or (at your option) any
  330. later version.
  331.  
  332. This library is distributed in the hope that it will be useful, but WITHOUT ANY
  333. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  334. PARTICULAR PURPOSE.  See the GNU Library General Public License for more
  335. details.
  336.  
  337. You should have received a copy of the GNU Library General Public License along
  338. with this library; if not, write to the Free Software Foundation, Inc., 59
  339. Temple Place - Suite 330, Boston, MA  02111-1307  USA.
  340.  
  341. =cut
  342.